/**
 * 数据服务模块 - 负责所有数据的存储、加载和同步
 */

// 存储页面结构数据
let pagesData = { pages: [] };

// 存储页面内容
let pageContents = {};

// 当前激活的页面ID
let activePageId = null;

// 调试开关
const DEBUG = true;

// 调试日志
function logDebug(...args) {
    if (DEBUG) {
        console.log('[DataService]', ...args);
    }
}

/**
 * 获取服务器配置信息
 */
async function getServerConfig() {
    try {
        const response = await fetch('/server-config.json');
        if (!response.ok) throw new Error('配置获取失败');
        return await response.json();
    } catch (err) {
        console.warn('获取动态配置失败，使用默认端口3000');
        return { port: 3000 }; // 默认回退
    }
}

/**
 * 保存页面结构数据到文件系统
 */
async function savePagesDataToFile() {
    try {
        const config = await getServerConfig();
        const pagesDataToSave = JSON.stringify(pagesData);
        
        logDebug('正在保存页面结构数据到文件...');
        
        const response = await fetch(`http://localhost:${config.port}/save-metadata`, {
            method: 'POST',
            headers: {
                'Content-Type': 'application/json'
            },
            body: JSON.stringify({ data: pagesDataToSave })
        });
        
        if (response.ok) {
            logDebug('页面结构数据保存成功');
            showToast('页面结构已保存');
            return true;
        } else {
            console.error('页面结构数据保存失败');
            showToast('页面结构保存失败', 'error');
            return false;
        }
    } catch (error) {
        console.error('保存页面结构数据出错:', error);
        showToast('页面结构保存失败: ' + error.message, 'error');
        return false;
    }
}

/**
 * 保存页面结构数据到localStorage和文件系统
 */
function savePagesData() {
    // 保存到localStorage
    localStorage.setItem('pagesData', JSON.stringify(pagesData));
    logDebug('页面结构已保存到localStorage');
    
    // 同时保存到文件系统
    savePagesDataToFile();
}

/**
 * 从文件系统加载页面结构数据
 */
async function loadPagesDataFromFile() {
    try {
        const config = await getServerConfig();
        logDebug('尝试从文件加载页面结构元数据...');
        
        const response = await fetch(`http://localhost:${config.port}/load-metadata`);
        
        if (response.ok) {
            const data = await response.text();
            if (data && data.trim()) {
                // 解析JSON数据
                try {
                    const loadedData = JSON.parse(data);
                    logDebug('从文件加载的数据:', loadedData);
                    
                    // 更新pagesData
                    pagesData = loadedData;
                    // 同步到localStorage
                    localStorage.setItem('pagesData', JSON.stringify(pagesData));
                    logDebug('从文件加载页面结构数据成功');
                    return true;
                } catch (e) {
                    console.error('解析元数据JSON失败:', e);
                    return false;
                }
            } else {
                logDebug('从文件加载的元数据为空');
            }
        } else {
            logDebug('元数据文件加载失败:', response.status);
        }
        return false;
    } catch (error) {
        console.error('加载页面结构数据出错:', error);
        return false;
    }
}

/**
 * 保存页面内容到文件系统
 */
async function savePageToFile(pageId, content) {
    if (!pageId || !content) {
        console.error('保存页面内容失败: 缺少页面ID或内容');
        return false;
    }

    try {
        const config = await getServerConfig();
        const response = await fetch(`http://localhost:${config.port}/save-page`, {
            method: 'POST',
            headers: {
                'Content-Type': 'application/json'
            },
            body: JSON.stringify({ pageId, content })
        });

        if (response.ok) {
            logDebug(`页面 ${pageId} 内容保存成功`);
            return true;
        } else {
            console.error(`页面 ${pageId} 内容保存失败`);
            return false;
        }
    } catch (error) {
        console.error('保存页面内容出错:', error);
        return false;
    }
}

/**
 * 从文件系统加载页面内容
 */
async function loadPageContentFromFile(pageId) {
    if (!pageId) {
        console.error('加载页面内容失败: 缺少页面ID');
        return null;
    }

    try {
        const config = await getServerConfig();
        logDebug(`尝试从文件加载页面内容: ${pageId}`);
        
        const response = await fetch(`http://localhost:${config.port}/load-page/${pageId}`);
        
        if (response.ok) {
            const content = await response.text();
            if (content && content.trim()) {
                logDebug(`页面 ${pageId} 内容加载成功，长度: ${content.length}`);
                return content;
            } else {
                logDebug(`页面 ${pageId} 内容为空`);
            }
        } else {
            logDebug(`页面 ${pageId} 内容加载失败: ${response.status}`);
        }
        return null;
    } catch (error) {
        console.error('加载页面内容出错:', error);
        return null;
    }
}

/**
 * 保存当前页面内容到localStorage和文件系统
 */
async function savePageContent() {
    if (!activePageId) return;

    const editor = document.getElementById('editor');
    if (!editor) return;

    const content = editor.innerHTML;
    
    // 保存到localStorage
    pageContents[activePageId] = content;
    localStorage.setItem('pageContents', JSON.stringify(pageContents));
    
    // 定义节流变量
    if (typeof window.saveTimeout === 'undefined') {
        window.saveTimeout = null;
    }
    
    // 使用节流保存到文件系统
    if (window.saveTimeout) {
        clearTimeout(window.saveTimeout);
    }
    
    window.saveTimeout = setTimeout(() => {
        savePageToFile(activePageId, content);
        window.saveTimeout = null;
    }, 2000); // 2秒内只保存一次
}

/**
 * 强制保存所有数据
 */
async function forceSaveAllData() {
    logDebug('强制保存所有数据');
    
    // 保存页面结构
    savePagesData();
    
    // 保存当前页面内容
    if (activePageId) {
        const editor = document.getElementById('editor');
        if (editor) {
            // 保存到localStorage
            pageContents[activePageId] = editor.innerHTML;
            localStorage.setItem('pageContents', JSON.stringify(pageContents));
            
            // 保存到文件
            await savePageToFile(activePageId, editor.innerHTML);
            
            showToast('所有数据已保存');
        }
    }
}

/**
 * 初始化默认页面
 */
function initDefaultPages() {
    logDebug('初始化默认页面');
    
    // 强制创建默认数据，确保左侧导航有内容
    pagesData.pages = [];
    
    // 使用固定的ID
    const welcomePageId = 'page_welcome';
    pagesData.pages.push({
        id: welcomePageId,
        title: '欢迎页面',
        type: 'page'
    });
    
    // 创建一个默认目录，使用固定ID
    const defaultFolderId = 'dir_default';
    pagesData.pages.push({
        id: defaultFolderId,
        title: '我的笔记',
        type: 'directory',
        expanded: true,
        children: [
            {
                id: 'page_getting_started',
                title: '开始使用',
                type: 'page'
            }
        ]
    });
    
    // 设置欢迎页面的内容
    pageContents[welcomePageId] = '<div class="title-block" contenteditable="true">欢迎使用</div><div class="block"><div class="block-drag-handle">⋮⋮</div><div class="text-block" contenteditable="true">这是一个简单的示例页面，您可以：<br>• 在左侧创建新页面或文件夹<br>• 右键点击页面进行更多操作<br>• 使用搜索框查找内容</div></div>';
    
    // 保存到localStorage
    localStorage.setItem('pagesData', JSON.stringify(pagesData));
    localStorage.setItem('pageContents', JSON.stringify(pageContents));
    
    // 设置欢迎页面为激活页面
    activePageId = welcomePageId;
    localStorage.setItem('activePageId', activePageId);
    
    logDebug('初始化默认页面完成', pagesData);
    
    // 确保保存到文件系统
    savePagesDataToFile();
}

/**
 * 初始化数据
 */
async function initData() {
    logDebug('初始化数据服务');
    
    // 尝试从localStorage加载数据
    const savedPagesData = localStorage.getItem('pagesData');
    if (savedPagesData) {
        try {
            pagesData = JSON.parse(savedPagesData);
            logDebug('从localStorage加载页面数据成功', pagesData);
        } catch (e) {
            console.error('解析localStorage中的pagesData失败', e);
            pagesData = { pages: [] };
        }
    }
    
    const savedPageContents = localStorage.getItem('pageContents');
    if (savedPageContents) {
        try {
            pageContents = JSON.parse(savedPageContents);
            logDebug('从localStorage加载页面内容成功');
        } catch (e) {
            console.error('解析localStorage中的pageContents失败', e);
            pageContents = {};
        }
    }
    
    const savedActivePageId = localStorage.getItem('activePageId');
    if (savedActivePageId) {
        activePageId = savedActivePageId;
        logDebug('从localStorage加载活动页面ID:', activePageId);
    }
    
    try {
        // 尝试从文件加载页面结构数据
        const loadedFromFile = await loadPagesDataFromFile();
        
        // 如果没有任何数据，初始化默认数据
        if (!loadedFromFile && (!savedPagesData || pagesData.pages.length === 0)) {
            logDebug('没有找到任何数据，初始化默认页面');
            initDefaultPages();
        } else {
            // 确保数据同步到文件系统
            if (!loadedFromFile && savedPagesData) {
                logDebug('从localStorage加载了数据，同步到文件系统');
                await savePagesDataToFile();
            }
        }
        
        logDebug('数据初始化完成，页面数量:', pagesData.pages.length);
    } catch (error) {
        console.error('初始化数据出错:', error);
        
        // 如果失败但本地有数据，使用本地数据
        if (savedPagesData && pagesData.pages.length > 0) {
            logDebug('使用localStorage中的数据作为备份');
        } else {
            // 否则创建默认数据
            logDebug('创建默认页面作为备份');
            initDefaultPages();
        }
    }
    
    return { pagesData, pageContents, activePageId };
}

/**
 * 根据ID查找页面
 */
function findPageById(pageId) {
    const findInPages = (pages) => {
        for (let i = 0; i < pages.length; i++) {
            if (pages[i].id === pageId) {
                return pages[i];
            }
            if (pages[i].children) {
                const found = findInPages(pages[i].children);
                if (found) {
                    return found;
                }
            }
        }
        return null;
    };
    
    return findInPages(pagesData.pages);
}

/**
 * 创建新页面
 */
function createNewPage(parentId, type = 'page') {
    // 生成一个基于时间戳和类型的唯一ID
    const timestamp = Date.now();
    const randomStr = Math.random().toString(36).substring(2, 8);
    const newId = type === 'directory' ? 
        `dir_${timestamp}_${randomStr}` : 
        `page_${timestamp}_${randomStr}`;

    const newPage = {
        id: newId,
        title: type === 'directory' ? '新建文件夹' : '无标题',
        type: type,
        expanded: true
    };
    
    if (type === 'directory') {
        newPage.children = [];
    }
    
    // 添加到根目录或指定父页面
    if (!parentId) {
        pagesData.pages.push(newPage);
    } else {
        // 递归查找父页面
        const addToParent = (pages, id) => {
            for (let i = 0; i < pages.length; i++) {
                if (pages[i].id === id) {
                    if (!pages[i].children) {
                        pages[i].children = [];
                    }
                    pages[i].children.push(newPage);
                    return true;
                }
                if (pages[i].children) {
                    if (addToParent(pages[i].children, id)) {
                        return true;
                    }
                }
            }
            return false;
        };
        
        addToParent(pagesData.pages, parentId);
    }
    
    // 保存页面数据
    savePagesData();
    
    return newPage;
}

/**
 * 删除页面
 */
function deletePage(pageId) {
    if (!pageId) return false;
    
    const removePage = (pages, id) => {
        for (let i = 0; i < pages.length; i++) {
            if (pages[i].id === id) {
                pages.splice(i, 1);
                return true;
            }
            if (pages[i].children) {
                if (removePage(pages[i].children, id)) {
                    return true;
                }
            }
        }
        return false;
    };
    
    // 从页面数据中删除
    if (removePage(pagesData.pages, pageId)) {
        // 如果删除的是当前活动页面，需要选择其他页面
        if (activePageId === pageId) {
            activePageId = null;
            localStorage.removeItem('activePageId');
        }
        
        // 从页面内容中删除
        if (pageContents[pageId]) {
            delete pageContents[pageId];
            localStorage.setItem('pageContents', JSON.stringify(pageContents));
        }
        
        // 保存页面数据
        savePagesData();
        return true;
    }
    
    return false;
}

/**
 * 显示通知提示
 */
function showToast(message, type = 'success') {
    // 检查是否已存在toast元素
    let toast = document.querySelector('.toast');
    if (!toast) {
        toast = document.createElement('div');
        toast.className = 'toast';
        document.body.appendChild(toast);
    }
    
    // 设置类型和消息
    toast.className = `toast ${type}`;
    toast.textContent = message;
    
    // 显示toast
    setTimeout(() => {
        toast.classList.add('show');
    }, 10);
    
    // 3秒后隐藏
    setTimeout(() => {
        toast.classList.remove('show');
    }, 3000);
}

// 暴露公共接口
window.DataService = {
    // 数据
    getPagesData: () => pagesData,
    getPageContents: () => pageContents,
    getActivePageId: () => activePageId,
    setActivePageId: (id) => { activePageId = id; localStorage.setItem('activePageId', id); },
    
    // 页面操作
    findPageById,
    createNewPage,
    deletePage,
    
    // 数据加载和保存
    initData,
    savePagesData,
    savePageContent,
    forceSaveAllData,
    loadPageContentFromFile,
    
    // 工具函数
    showToast
}; 